FastAPI Dependency Injection: Erweiterte DI-Container-Architektur

FastAPI hat sich mit seinem intuitiven Design und seinen leistungsstarken Funktionen zu einem Favoriten für die Erstellung moderner Web-APIs in Python entwickelt. Eine seiner Kernstärken liegt in der nahtlosen Integration mit Dependency Injection (DI), die es Entwicklern ermöglicht, lose gekoppelte, testbare und wartbare Anwendungen zu erstellen. Während das integrierte DI-System von FastAPI für einfache Anwendungsfälle hervorragend geeignet ist, profitieren komplexere Projekte oft von einer strukturierteren und fortschrittlicheren DI-Container-Architektur. Dieser Artikel untersucht verschiedene Strategien zum Aufbau einer solchen Architektur und bietet praktische Beispiele und Einblicke für die Entwicklung robuster und skalierbarer Anwendungen.

Verständnis von Dependency Injection (DI) und Inversion of Control (IoC)

Bevor wir uns mit fortschrittlichen DI-Container-Architekturen befassen, klären wir die grundlegenden Konzepte:

• Dependency Injection (DI): Ein Entwurfsmuster, bei dem Abhängigkeiten einer Komponente von externen Quellen bereitgestellt werden, anstatt sie intern zu erstellen. Dies fördert eine lose Kopplung und erleichtert das Testen und Wiederverwenden von Komponenten.
• Inversion of Control (IoC): Ein breiteres Prinzip, bei dem die Kontrolle über die Objekterstellung und -verwaltung umgekehrt wird – delegiert an ein Framework oder einen Container. DI ist eine spezifische Art von IoC.

FastAPI unterstützt DI nativ durch sein Abhängigkeitssystem. Sie definieren Abhängigkeiten als aufrufbare Objekte (Funktionen, Klassen usw.), und FastAPI löst sie automatisch auf und injiziert sie in Ihre Endpunktfunktionen oder andere Abhängigkeiten.

Beispiel (Grundlegendes FastAPI DI):

            
from fastapi import FastAPI, Depends

app = FastAPI()

# Abhängigkeit
def get_db():
    db = {"items": []}  # Simuliert eine Datenbankverbindung
    try:
        yield db
    finally:
        # Datenbankverbindung schließen (falls erforderlich)
        pass


# Endpunkt mit Dependency Injection
@app.get("/items/")
async def read_items(db: dict = Depends(get_db)):
    return db["items"]

            

              
                Copy
              
            
          

In diesem Beispiel ist get_db eine Abhängigkeit, die eine Datenbankverbindung bereitstellt. FastAPI ruft get_db automatisch auf und injiziert das Ergebnis (das db-Wörterbuch) in die Endpunktfunktion read_items.

Warum ein erweiterter DI-Container?

FastAPIs integrierte DI funktioniert gut für einfache Projekte, aber wenn die Komplexität von Anwendungen wächst, bietet ein ausgefeilterer DI-Container mehrere Vorteile:

• Zentralisierte Abhängigkeitsverwaltung: Ein dedizierter Container bietet eine einzige Quelle der Wahrheit für alle Abhängigkeiten, was die Verwaltung und das Verständnis der Abhängigkeiten der Anwendung erleichtert.
• Konfigurations- und Lebenszyklusverwaltung: Der Container kann die Konfiguration und den Lebenszyklus von Abhängigkeiten übernehmen, wie z. B. die Erstellung von Singletons, die Verwaltung von Verbindungen und die Freigabe von Ressourcen.
• Testbarkeit: Ein fortschrittlicher Container vereinfacht das Testen, indem er es Ihnen ermöglicht, Abhängigkeiten einfach durch Mock-Objekte oder Test-Doubles zu ersetzen.
• Entkopplung: Fördert eine stärkere Entkopplung zwischen Komponenten, reduziert Abhängigkeiten und verbessert die Code-Wartbarkeit.
• Erweiterbarkeit: Ein erweiterbarer Container ermöglicht es Ihnen, bei Bedarf benutzerdefinierte Funktionen und Integrationen hinzuzufügen.

Strategien zum Aufbau eines erweiterten DI-Containers

Es gibt verschiedene Ansätze zum Aufbau eines erweiterten DI-Containers in FastAPI. Hier sind einige gängige Strategien:

1. Verwendung einer dedizierten DI-Bibliothek (z. B. `injector`, `dependency_injector`)

Es gibt mehrere leistungsstarke DI-Bibliotheken für Python, wie z. B. injector und dependency_injector. Diese Bibliotheken bieten einen umfassenden Satz von Funktionen zur Verwaltung von Abhängigkeiten, darunter:

• Binding: Definieren, wie Abhängigkeiten aufgelöst und injiziert werden.
• Scopes: Steuern des Lebenszyklus von Abhängigkeiten (z. B. Singleton, Transient).
• Konfiguration: Verwalten von Konfigurationseinstellungen für Abhängigkeiten.
• AOP (Aspect-Oriented Programming): Abfangen von Methodenaufrufen für übergreifende Belange.

Beispiel mit `dependency_injector`

dependency_injector ist eine beliebte Wahl für den Aufbau von DI-Containern. Wir illustrieren die Verwendung anhand eines Beispiels:

            
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Abhängigkeiten definieren
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string
        # Datenbankverbindung initialisieren
        print(f"Connecting to database: {self.connection_string}")

    def get_items(self):
        # Abrufen von Elementen aus der Datenbank simulieren
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        # Simulieren einer Datenbankabfrage, um alle Benutzer abzurufen
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Container definieren
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# FastAPI-App erstellen
app = FastAPI()

# Container konfigurieren (aus einer Umgebungsvariablen)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # Ermöglicht die Injektion von Abhängigkeiten in FastAPI-Endpunkte

# Abhängigkeit für FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endpunkt mit injizierter Abhängigkeit
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Container-Initialisierung
    container.init_resources()

            

              
                Copy
              
            
          

Erklärung:

• Wir definieren unsere Abhängigkeiten (Database, UserRepository, Settings) als normale Python-Klassen.
• Wir erstellen eine Container-Klasse, die von containers.DeclarativeContainer erbt. Diese Klasse definiert die Abhängigkeiten und ihre Provider (z. B. providers.Singleton für Singletons, providers.Factory zum Erstellen neuer Instanzen bei jeder Abfrage).
• Die Zeile container.wire([__name__]) aktiviert die Dependency Injection in FastAPI-Endpunkten.
• Die Funktion get_user_repository ist eine FastAPI-Abhängigkeit, die container.user_repository.provided verwendet, um die UserRepository-Instanz aus dem Container abzurufen.
• Die Endpunktfunktion read_users injiziert die UserRepository-Abhängigkeit.
• Das `config` ermöglicht es Ihnen, die Abhängigkeitskonfigurationen zu externalisieren. Sie können dann aus Umgebungsvariablen, Konfigurationsdateien usw. stammen.
• Das `startup_event` wird verwendet, um die im Container verwalteten Ressourcen zu initialisieren.

2. Implementierung eines benutzerdefinierten DI-Containers

Für mehr Kontrolle über den DI-Prozess können Sie einen benutzerdefinierten DI-Container implementieren. Dieser Ansatz erfordert mehr Aufwand, ermöglicht es Ihnen jedoch, den Container an Ihre spezifischen Bedürfnisse anzupassen.

Beispiel für einen grundlegenden benutzerdefinierten DI-Container:

            
from typing import Callable, Dict, Type, Any
from fastapi import FastAPI, Depends

class Container:
    def __init__(self):
        self.dependencies: Dict[Type[Any], Callable[..., Any]] = {}
        self.instances: Dict[Type[Any], Any] = {}

    def register(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.dependencies[dependency_type] = provider

    def resolve(self, dependency_type: Type[Any]) -> Any:
        if dependency_type in self.instances:
            return self.instances[dependency_type]

        if dependency_type not in self.dependencies:
            raise Exception(f"Dependency {dependency_type} not registered.")

        provider = self.dependencies[dependency_type]
        instance = provider()
        return instance

    def singleton(self, dependency_type: Type[Any], provider: Callable[..., Any]):
        self.register(dependency_type, provider)
        self.instances[dependency_type] = provider()


# Beispielabhängigkeiten
class PaymentGateway:
    def process_payment(self, amount: float) -> bool:
        print(f"Processing payment of ${amount}")
        return True # Zahlungserfolg simulieren


class NotificationService:
    def send_notification(self, message: str):
        print(f"Sending notification: {message}")


# Beispielverwendung
container = Container()
container.singleton(PaymentGateway, PaymentGateway)
container.singleton(NotificationService, NotificationService)

app = FastAPI()

# FastAPI-Abhängigkeit
def get_payment_gateway(payment_gateway: PaymentGateway = Depends(lambda: container.resolve(PaymentGateway))):
    return payment_gateway


def get_notification_service(notification_service: NotificationService = Depends(lambda: container.resolve(NotificationService))):
    return notification_service


@app.post("/purchase/")
async def purchase_item(payment_gateway: PaymentGateway = Depends(get_payment_gateway), notification_service: NotificationService = Depends(get_notification_service)):
    if payment_gateway.process_payment(100.0):
        notification_service.send_notification("Purchase successful!")
        return {"message": "Purchase successful"}
    else:
        return {"message": "Purchase failed"}

            

              
                Copy
              
            
          

Erklärung:

• Die Container-Klasse verwaltet ein Wörterbuch von Abhängigkeiten und ihren Providern.
• Die register-Methode registriert eine Abhängigkeit mit ihrem Provider.
• Die resolve-Methode löst eine Abhängigkeit auf, indem sie ihren Provider aufruft.
• Die singleton-Methode registriert eine Abhängigkeit und erstellt eine einzelne Instanz davon.
• FastAPI-Abhängigkeiten werden mit einer Lambda-Funktion erstellt, um Abhängigkeiten aus dem Container aufzulösen.

3. Verwendung von FastAPI's `Depends` mit einer Factory-Funktion

Anstatt eines vollwertigen DI-Containers können Sie FastAPI's Depends zusammen mit Factory-Funktionen verwenden, um ein gewisses Maß an Abhängigkeitsverwaltung zu erreichen. Dieser Ansatz ist einfacher als die Implementierung eines benutzerdefinierten Containers, bietet aber dennoch einige Vorteile gegenüber der direkten Instanziierung von Abhängigkeiten innerhalb von Endpunktfunktionen.

            
from fastapi import FastAPI, Depends
from typing import Callable

# Abhängigkeiten definieren
class EmailService:
    def __init__(self, smtp_server: str):
        self.smtp_server = smtp_server

    def send_email(self, recipient: str, subject: str, body: str):
        print(f"Sending email to {recipient} via {self.smtp_server}: {subject} - {body}")


# Factory-Funktion für EmailService
def create_email_service(smtp_server: str) -> EmailService:
    return EmailService(smtp_server=smtp_server)


# FastAPI
app = FastAPI()

# FastAPI-Abhängigkeit, die die Factory-Funktion und Depends nutzt
def get_email_service(email_service: EmailService = Depends(lambda: create_email_service(smtp_server="smtp.example.com"))):
    return email_service


@app.post("/send-email/")
async def send_email(recipient: str, subject: str, body: str, email_service: EmailService = Depends(get_email_service)):
    email_service.send_email(recipient=recipient, subject=subject, body=body)
    return {"message": "Email sent!"}

            

              
                Copy
              
            
          

Erklärung:

• Wir definieren eine Factory-Funktion (create_email_service), die Instanzen der EmailService-Abhängigkeit erstellt.
• Die get_email_service-Abhängigkeit verwendet Depends und ein Lambda, um die Factory-Funktion aufzurufen und eine Instanz von EmailService bereitzustellen.
• Die Endpunktfunktion send_email injiziert die EmailService-Abhängigkeit.

Fortgeschrittene Überlegungen

1. Scopes und Lebenszyklen

DI-Container bieten oft Funktionen zur Verwaltung des Lebenszyklus von Abhängigkeiten. Gängige Scopes sind:

• Singleton: Eine einzelne Instanz der Abhängigkeit wird erstellt und während der gesamten Lebensdauer der Anwendung wiederverwendet. Dies ist für zustandslose Abhängigkeiten oder solche mit globalem Geltungsbereich geeignet.
• Transient: Bei jeder Anforderung wird eine neue Instanz der Abhängigkeit erstellt. Dies ist für zustandsbehaftete Abhängigkeiten oder solche, die voneinander isoliert werden müssen, geeignet.
• Request: Für jede eingehende Anfrage wird eine einzelne Instanz der Abhängigkeit erstellt. Dies ist für Abhängigkeiten geeignet, die den Zustand im Kontext einer einzelnen Anfrage aufrechterhalten müssen.

Die Bibliothek dependency_injector bietet integrierte Unterstützung für Scopes. Für benutzerdefinierte Container müssen Sie die Logik zur Scope-Verwaltung selbst implementieren.

2. Konfiguration

Abhängigkeiten erfordern oft Konfigurationseinstellungen wie Datenbankverbindungszeichenfolgen, API-Schlüssel und Feature-Flags. DI-Container können bei der Verwaltung dieser Einstellungen helfen, indem sie eine zentrale Möglichkeit zur Erfassung und Injektion von Konfigurationswerten bieten.

Im Beispiel von dependency_injector erlaubt der config-Provider die Konfiguration über Umgebungsvariablen. Für benutzerdefinierte Container können Sie die Konfiguration aus Dateien oder Umgebungsvariablen laden und im Container speichern.

3. Testen

Einer der Hauptvorteile von DI ist die verbesserte Testbarkeit. Mit einem DI-Container können Sie während des Testens echte Abhängigkeiten leicht durch Mock-Objekte oder Test-Doubles ersetzen.

Beispiel (Testen mit `dependency_injector`):

            
import pytest
from unittest.mock import MagicMock
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient

# Abhängigkeiten definieren (wie zuvor)
class Database:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    def get_items(self):
        return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]


class UserRepository:
    def __init__(self, database: Database):
        self.database = database

    def get_all_users(self):
        return [{"id": "user1", "name": "Alice"},{"id": "user2", "name": "Bob"}]

class Settings:
    def __init__(self, database_url):
        self.database_url = database_url

# Container definieren (wie zuvor)
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    settings = providers.Singleton(Settings, database_url = config.database_url)
    database = providers.Singleton(Database, connection_string=config.database_url)
    user_repository = providers.Factory(UserRepository, database=database)

# FastAPI-App erstellen (wie zuvor)
app = FastAPI()

# Container konfigurieren (aus einer Umgebungsvariablen)
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__]) # Ermöglicht die Injektion von Abhängigkeiten in FastAPI-Endpunkte

# Abhängigkeit für FastAPI
def get_user_repository(user_repository: UserRepository = Depends(container.user_repository.provided)) -> UserRepository:
    return user_repository


# Endpunkt mit injizierter Abhängigkeit (wie zuvor)
@app.get("/users/")
async def read_users(user_repository: UserRepository = Depends(get_user_repository)):
    return user_repository.get_all_users()

@app.on_event("startup")
async def startup_event():
    # Container-Initialisierung
    container.init_resources()

# Test
@pytest.fixture
def test_client():
    # Die Datenbankabhängigkeit durch ein Mock ersetzen
    database_mock = MagicMock(spec=Database)
    database_mock.get_items.return_value = [{"id": 3, "name": "Test Item"}]

    user_repository_mock = MagicMock(spec = UserRepository)
    user_repository_mock.get_all_users.return_value = [{"id": "test_user", "name": "Test User"}]

    # Container mit Mock-Abhängigkeiten überschreiben
    container.user_repository.override(providers.Factory(lambda: user_repository_mock))

    with TestClient(app) as client:
        yield client
    container.user_repository.reset() 


def test_read_users(test_client: TestClient):
    response = test_client.get("/users/")
    assert response.status_code == 200
    assert response.json() ==  [{"id": "test_user", "name": "Test User"}]

            

              
                Copy
              
            
          

Erklärung:

• Wir erstellen ein Mock-Objekt für die Database-Abhängigkeit mithilfe von MagicMock.
• Wir überschreiben den database-Provider im Container mit dem Mock-Objekt mithilfe von container.database.override().
• Die Testfunktion test_read_items verwendet nun die Mock-Datenbankabhängigkeit.
• Nach der Ausführung des Tests wird die überschriebene Abhängigkeit des Containers zurückgesetzt.

4. Asynchrone Abhängigkeiten

FastAPI basiert auf asynchroner Programmierung (async/await). Wenn Sie mit asynchronen Abhängigkeiten arbeiten (z. B. asynchrone Datenbankverbindungen), stellen Sie sicher, dass Ihr DI-Container und Ihre Abhängigkeits-Provider asynchrone Operationen unterstützen.

Beispiel (Asynchrone Abhängigkeit mit `dependency_injector`):

            
import asyncio
from dependency_injector import containers, providers
from fastapi import FastAPI, Depends

# Asynchrone Abhängigkeit definieren
class AsyncDatabase:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string

    async def connect(self):
        print(f"Connecting to database: {self.connection_string}")
        await asyncio.sleep(0.1) # Verbindungszeit simulieren

    async def fetch_data(self):
        await asyncio.sleep(0.1) # Datenbankabfrage simulieren
        return [{"id": 1, "name": "Async Item 1"}]

# Container definieren
class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    database = providers.Singleton(AsyncDatabase, connection_string=config.database_url)

# FastAPI-App erstellen
app = FastAPI()

# Container konfigurieren
container = Container()
container.config.database_url.from_env("DATABASE_URL", default="sqlite:///:memory:")
container.wire([__name__])

# Abhängigkeit für FastAPI
async def get_async_database(database: AsyncDatabase = Depends(container.database.provided)) -> AsyncDatabase:
    await database.connect()
    return database


# Endpunkt mit injizierter Abhängigkeit
@app.get("/async-items/")
async def read_async_items(database: AsyncDatabase = Depends(get_async_database)):
    data = await database.fetch_data()
    return data


@app.on_event("startup")
async def startup_event():
    # Container-Initialisierung
    container.init_resources()

            

              
                Copy
              
            
          

Erklärung:

• Die Klasse AsyncDatabase definiert asynchrone Methoden mithilfe von async und await.
• Die Abhängigkeit get_async_database wird ebenfalls als asynchrone Funktion definiert.
• Die Endpunktfunktion read_async_items ist als async gekennzeichnet und wartet auf das Ergebnis von database.fetch_data().

Die richtige Vorgehensweise wählen

Der beste Ansatz zum Aufbau eines erweiterten DI-Containers hängt von der Komplexität Ihrer Anwendung und Ihren spezifischen Anforderungen ab:

• Für kleine bis mittelgroße Projekte: Die integrierte DI von FastAPI oder ein Factory-Funktionsansatz mit Depends können ausreichend sein.
• Für größere, komplexere Projekte: Eine dedizierte DI-Bibliothek wie dependency_injector bietet einen umfassenden Satz von Funktionen zur Verwaltung von Abhängigkeiten.
• Für Projekte, die eine detaillierte Kontrolle über den DI-Prozess erfordern: Die Implementierung eines benutzerdefinierten DI-Containers kann die beste Option sein.

Fazit

Dependency Injection ist eine leistungsstarke Technik zum Aufbau skalierbarer, wartbarer und testbarer Anwendungen. Während das integrierte DI-System von FastAPI für einfache Anwendungsfälle hervorragend geeignet ist, kann eine fortschrittliche DI-Container-Architektur für komplexere Projekte erhebliche Vorteile bieten. Durch die Wahl des richtigen Ansatzes und die Nutzung der Funktionen von DI-Bibliotheken oder die Implementierung eines benutzerdefinierten Containers können Sie ein robustes und flexibles Abhängigkeitsverwaltungssystem erstellen, das die Gesamtqualität und Wartbarkeit Ihrer FastAPI-Anwendungen verbessert.

Globale Überlegungen

Bei der Konzeption von DI-Containern für globale Anwendungen ist es wichtig, die folgenden Punkte zu berücksichtigen:

• Lokalisierung: Abhängigkeiten im Zusammenhang mit der Lokalisierung (z. B. Spracheinstellungen, Datumsformate) sollten vom DI-Container verwaltet werden, um die Konsistenz über verschiedene Regionen hinweg zu gewährleisten.
• Zeitzonen: Abhängigkeiten, die Zeitzonenkonvertierungen handhaben, sollten injiziert werden, um die Kodierung von Zeitzoneninformationen zu vermeiden.
• Währung: Abhängigkeiten für Währungskonvertierung und -formatierung sollten vom Container verwaltet werden, um verschiedene Währungen zu unterstützen.
• Regionale Einstellungen: Andere regionale Einstellungen wie Zahlenformate und Adressformate sollten ebenfalls vom DI-Container verwaltet werden.
• Multi-Tenancy: Für Multi-Tenant-Anwendungen sollte der DI-Container unterschiedliche Abhängigkeiten für verschiedene Mandanten bereitstellen können. Dies kann durch die Verwendung von Scopes oder benutzerdefinierter Abhängigkeitsauflösungslogik erreicht werden.
• Compliance und Sicherheit: Stellen Sie sicher, dass Ihre Strategie zur Abhängigkeitsverwaltung den relevanten Datenschutzbestimmungen (z. B. DSGVO, CCPA) und den bewährten Sicherheitspraktiken in verschiedenen Regionen entspricht. Behandeln Sie sensible Anmeldeinformationen und Konfigurationen sicher innerhalb des Containers.

Durch die Berücksichtigung dieser globalen Faktoren können Sie DI-Container erstellen, die sich gut für die Entwicklung von Anwendungen eignen, die in einer globalen Umgebung betrieben werden.